/**
 * 网络请求工具类
 * 封装uni.request，提供统一的接口调用方式
 */

// API基础配置
const BASE_URL = 'https://api.example.com'  // 实际项目中替换为真实API地址
const TIMEOUT = 10000  // 请求超时时间

/**
 * 请求状态码
 */
export const STATUS_CODES = {
  SUCCESS: 200,
  UNAUTHORIZED: 401,
  FORBIDDEN: 403,
  NOT_FOUND: 404,
  SERVER_ERROR: 500
}

/**
 * 获取请求头
 * @returns {Object} 请求头对象
 */
function getHeaders() {
  const headers = {
    'Content-Type': 'application/json',
    'Accept': 'application/json'
  }
  
  // 添加token到请求头
  try {
    const token = uni.getStorageSync('token')
    if (token) {
      headers['Authorization'] = `Bearer ${token}`
    }
  } catch (error) {
    console.warn('获取token失败:', error)
  }
  
  return headers
}

/**
 * 处理请求响应
 * @param {Object} response - 响应对象
 * @returns {Promise} 处理后的响应
 */
function handleResponse(response) {
  const { statusCode, data } = response
  
  // HTTP状态码检查
  if (statusCode === STATUS_CODES.UNAUTHORIZED) {
    // 未授权，清除token并跳转到登录页
    uni.removeStorageSync('token')
    uni.removeStorageSync('userInfo')
    uni.redirectTo({
      url: '/pages/login/login'
    })
    return Promise.reject(new Error('未授权，请重新登录'))
  }
  
  if (statusCode >= 400) {
    const errorMessage = data?.message || `请求失败，状态码：${statusCode}`
    return Promise.reject(new Error(errorMessage))
  }
  
  // 业务状态码检查（根据实际后端接口调整）
  if (data.code && data.code !== 0) {
    return Promise.reject(new Error(data.message || '请求失败'))
  }
  
  return data
}

/**
 * 处理请求错误
 * @param {Error} error - 错误对象
 */
function handleError(error) {
  console.error('请求错误:', error)
  
  let message = '网络错误，请检查网络连接'
  
  if (error.errMsg) {
    if (error.errMsg.includes('timeout')) {
      message = '请求超时，请重试'
    } else if (error.errMsg.includes('fail')) {
      message = '网络连接失败'
    }
  }
  
  uni.showToast({
    title: message,
    icon: 'none',
    duration: 2000
  })
  
  return Promise.reject(error)
}

/**
 * 统一请求方法
 * @param {Object} options - 请求选项
 * @returns {Promise} 请求Promise
 */
function request(options) {
  const {
    url,
    method = 'GET',
    data = {},
    header = {},
    showLoading = false,
    loadingText = '加载中...'
  } = options
  
  // 显示加载状态
  if (showLoading) {
    uni.showLoading({
      title: loadingText,
      mask: true
    })
  }
  
  return new Promise((resolve, reject) => {
    uni.request({
      url: url.startsWith('http') ? url : `${BASE_URL}${url}`,
      method,
      data,
      header: {
        ...getHeaders(),
        ...header
      },
      timeout: TIMEOUT,
      success: (response) => {
        try {
          const result = handleResponse(response)
          resolve(result)
        } catch (error) {
          reject(error)
        }
      },
      fail: (error) => {
        handleError(error)
        reject(error)
      },
      complete: () => {
        // 隐藏加载状态
        if (showLoading) {
          uni.hideLoading()
        }
      }
    })
  })
}

/**
 * GET请求
 * @param {string} url - 请求地址
 * @param {Object} params - 请求参数
 * @param {Object} options - 其他选项
 * @returns {Promise} 请求Promise
 */
export function get(url, params = {}, options = {}) {
  // 将参数拼接到URL中
  const queryString = Object.keys(params)
    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
    .join('&')
  
  const fullUrl = queryString ? `${url}?${queryString}` : url
  
  return request({
    url: fullUrl,
    method: 'GET',
    ...options
  })
}

/**
 * POST请求
 * @param {string} url - 请求地址
 * @param {Object} data - 请求数据
 * @param {Object} options - 其他选项
 * @returns {Promise} 请求Promise
 */
export function post(url, data = {}, options = {}) {
  return request({
    url,
    method: 'POST',
    data,
    ...options
  })
}

/**
 * PUT请求
 * @param {string} url - 请求地址
 * @param {Object} data - 请求数据
 * @param {Object} options - 其他选项
 * @returns {Promise} 请求Promise
 */
export function put(url, data = {}, options = {}) {
  return request({
    url,
    method: 'PUT',
    data,
    ...options
  })
}

/**
 * DELETE请求
 * @param {string} url - 请求地址
 * @param {Object} options - 其他选项
 * @returns {Promise} 请求Promise
 */
export function del(url, options = {}) {
  return request({
    url,
    method: 'DELETE',
    ...options
  })
}

/**
 * 上传文件
 * @param {string} url - 上传地址
 * @param {string} filePath - 文件路径
 * @param {Object} formData - 表单数据
 * @param {Object} options - 其他选项
 * @returns {Promise} 上传Promise
 */
export function upload(url, filePath, formData = {}, options = {}) {
  const {
    name = 'file',
    showProgress = true,
    ...otherOptions
  } = options
  
  return new Promise((resolve, reject) => {
    const uploadTask = uni.uploadFile({
      url: url.startsWith('http') ? url : `${BASE_URL}${url}`,
      filePath,
      name,
      formData,
      header: getHeaders(),
      success: (response) => {
        try {
          const data = JSON.parse(response.data)
          const result = handleResponse({
            statusCode: response.statusCode,
            data
          })
          resolve(result)
        } catch (error) {
          reject(error)
        }
      },
      fail: (error) => {
        handleError(error)
        reject(error)
      }
    })
    
    // 监听上传进度
    if (showProgress) {
      uploadTask.onProgressUpdate((progress) => {
        console.log('上传进度:', progress.progress)
        // 可以在这里更新UI进度条
      })
    }
  })
}

/**
 * 下载文件
 * @param {string} url - 下载地址
 * @param {Object} options - 其他选项
 * @returns {Promise} 下载Promise
 */
export function download(url, options = {}) {
  const {
    showProgress = true,
    ...otherOptions
  } = options
  
  return new Promise((resolve, reject) => {
    const downloadTask = uni.downloadFile({
      url: url.startsWith('http') ? url : `${BASE_URL}${url}`,
      header: getHeaders(),
      success: (response) => {
        if (response.statusCode === 200) {
          resolve(response.tempFilePath)
        } else {
          reject(new Error(`下载失败，状态码：${response.statusCode}`))
        }
      },
      fail: (error) => {
        handleError(error)
        reject(error)
      }
    })
    
    // 监听下载进度
    if (showProgress) {
      downloadTask.onProgressUpdate((progress) => {
        console.log('下载进度:', progress.progress)
        // 可以在这里更新UI进度条
      })
    }
  })
}

// 默认导出
export default {
  get,
  post,
  put,
  delete: del,
  upload,
  download,
  request
}